home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / i2c.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  29.7 KB  |  760 lines
  1. /* ------------------------------------------------------------------------- */
  2. /*                                         */
  3. /* i2c.h - definitions for the i2c-bus interface                 */
  4. /*                                         */
  5. /* ------------------------------------------------------------------------- */
  6. /*   Copyright (C) 1995-2000 Simon G. Vogl
  7.  
  8.     This program is free software; you can redistribute it and/or modify
  9.     it under the terms of the GNU General Public License as published by
  10.     the Free Software Foundation; either version 2 of the License, or
  11.     (at your option) any later version.
  12.  
  13.     This program is distributed in the hope that it will be useful,
  14.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.     GNU General Public License for more details.
  17.  
  18.     You should have received a copy of the GNU General Public License
  19.     along with this program; if not, write to the Free Software
  20.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.             */
  21. /* ------------------------------------------------------------------------- */
  22.  
  23. /* With some changes from Ky√∂sti M√§lkki <kmalkki@cc.hut.fi> and
  24.    Frodo Looijaard <frodol@dds.nl> */
  25.  
  26. #ifndef _LINUX_I2C_H
  27. #define _LINUX_I2C_H
  28.  
  29. #include <linux/types.h>
  30. #ifdef __KERNEL__
  31. #include <linux/module.h>
  32. #include <linux/i2c-id.h>
  33. #include <linux/mod_devicetable.h>
  34. #include <linux/device.h>    /* for struct device */
  35. #include <linux/sched.h>    /* for completion */
  36. #include <linux/mutex.h>
  37.  
  38. extern struct bus_type i2c_bus_type;
  39.  
  40. /* --- General options ------------------------------------------------    */
  41.  
  42. struct i2c_msg;
  43. struct i2c_algorithm;
  44. struct i2c_adapter;
  45. struct i2c_client;
  46. struct i2c_driver;
  47. union i2c_smbus_data;
  48. struct i2c_board_info;
  49.  
  50. /*
  51.  * The master routines are the ones normally used to transmit data to devices
  52.  * on a bus (or read from them). Apart from two basic transfer functions to
  53.  * transmit one message at a time, a more complex version can be used to
  54.  * transmit an arbitrary number of messages without interruption.
  55.  */
  56. extern int i2c_master_send(struct i2c_client *client, const char *buf,
  57.                int count);
  58. extern int i2c_master_recv(struct i2c_client *client, char *buf, int count);
  59.  
  60. /* Transfer num messages.
  61.  */
  62. extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
  63.             int num);
  64.  
  65. /* This is the very generalized SMBus access routine. You probably do not
  66.    want to use this, though; one of the functions below may be much easier,
  67.    and probably just as fast.
  68.    Note that we use i2c_adapter here, because you do not need a specific
  69.    smbus adapter to call this function. */
  70. extern s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
  71.               unsigned short flags, char read_write, u8 command,
  72.               int size, union i2c_smbus_data *data);
  73.  
  74. /* Now follow the 'nice' access routines. These also document the calling
  75.    conventions of i2c_smbus_xfer. */
  76.  
  77. extern s32 i2c_smbus_read_byte(struct i2c_client *client);
  78. extern s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value);
  79. extern s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command);
  80. extern s32 i2c_smbus_write_byte_data(struct i2c_client *client,
  81.                      u8 command, u8 value);
  82. extern s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command);
  83. extern s32 i2c_smbus_write_word_data(struct i2c_client *client,
  84.                      u8 command, u16 value);
  85. /* Returns the number of read bytes */
  86. extern s32 i2c_smbus_read_block_data(struct i2c_client *client,
  87.                      u8 command, u8 *values);
  88. extern s32 i2c_smbus_write_block_data(struct i2c_client *client,
  89.                       u8 command, u8 length, const u8 *values);
  90. /* Returns the number of read bytes */
  91. extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client,
  92.                      u8 command, u8 length, u8 *values);
  93. extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client,
  94.                       u8 command, u8 length,
  95.                       const u8 *values);
  96.  
  97. /**
  98.  * struct i2c_driver - represent an I2C device driver
  99.  * @id: Unique driver ID (optional)
  100.  * @class: What kind of i2c device we instantiate (for detect)
  101.  * @attach_adapter: Callback for bus addition (for legacy drivers)
  102.  * @detach_adapter: Callback for bus removal (for legacy drivers)
  103.  * @detach_client: Callback for device removal (for legacy drivers)
  104.  * @probe: Callback for device binding (new-style drivers)
  105.  * @remove: Callback for device unbinding (new-style drivers)
  106.  * @shutdown: Callback for device shutdown
  107.  * @suspend: Callback for device suspend
  108.  * @resume: Callback for device resume
  109.  * @command: Callback for bus-wide signaling (optional)
  110.  * @driver: Device driver model driver
  111.  * @id_table: List of I2C devices supported by this driver
  112.  * @detect: Callback for device detection
  113.  * @address_data: The I2C addresses to probe, ignore or force (for detect)
  114.  * @clients: List of detected clients we created (for i2c-core use only)
  115.  *
  116.  * The driver.owner field should be set to the module owner of this driver.
  117.  * The driver.name field should be set to the name of this driver.
  118.  *
  119.  * For automatic device detection, both @detect and @address_data must
  120.  * be defined. @class should also be set, otherwise only devices forced
  121.  * with module parameters will be created. The detect function must
  122.  * fill at least the name field of the i2c_board_info structure it is
  123.  * handed upon successful detection, and possibly also the flags field.
  124.  *
  125.  * If @detect is missing, the driver will still work fine for enumerated
  126.  * devices. Detected devices simply won't be supported. This is expected
  127.  * for the many I2C/SMBus devices which can't be detected reliably, and
  128.  * the ones which can always be enumerated in practice.
  129.  *
  130.  * The i2c_client structure which is handed to the @detect callback is
  131.  * not a real i2c_client. It is initialized just enough so that you can
  132.  * call i2c_smbus_read_byte_data and friends on it. Don't do anything
  133.  * else with it. In particular, calling dev_dbg and friends on it is
  134.  * not allowed.
  135.  */
  136. struct i2c_driver {
  137.     int id;
  138.     unsigned int class;
  139.  
  140.     /* Notifies the driver that a new bus has appeared. This routine
  141.      * can be used by the driver to test if the bus meets its conditions
  142.      * & seek for the presence of the chip(s) it supports. If found, it
  143.      * registers the client(s) that are on the bus to the i2c admin. via
  144.      * i2c_attach_client.  (LEGACY I2C DRIVERS ONLY)
  145.      */
  146.     int (*attach_adapter)(struct i2c_adapter *);
  147.     int (*detach_adapter)(struct i2c_adapter *);
  148.  
  149.     /* tells the driver that a client is about to be deleted & gives it
  150.      * the chance to remove its private data. Also, if the client struct
  151.      * has been dynamically allocated by the driver in the function above,
  152.      * it must be freed here.  (LEGACY I2C DRIVERS ONLY)
  153.      */
  154.     int (*detach_client)(struct i2c_client *);
  155.  
  156.     /* Standard driver model interfaces, for "new style" i2c drivers.
  157.      * With the driver model, device enumeration is NEVER done by drivers;
  158.      * it's done by infrastructure.  (NEW STYLE DRIVERS ONLY)
  159.      */
  160.     int (*probe)(struct i2c_client *, const struct i2c_device_id *);
  161.     int (*remove)(struct i2c_client *);
  162.  
  163.     /* driver model interfaces that don't relate to enumeration  */
  164.     void (*shutdown)(struct i2c_client *);
  165.     int (*suspend)(struct i2c_client *, pm_message_t mesg);
  166.     int (*resume)(struct i2c_client *);
  167.  
  168.     /* a ioctl like command that can be used to perform specific functions
  169.      * with the device.
  170.      */
  171.     int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
  172.  
  173.     struct device_driver driver;
  174.     const struct i2c_device_id *id_table;
  175.  
  176.     /* Device detection callback for automatic device creation */
  177.     int (*detect)(struct i2c_client *, int kind, struct i2c_board_info *);
  178.     const struct i2c_client_address_data *address_data;
  179.     struct list_head clients;
  180. };
  181. #define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)
  182.  
  183. /**
  184.  * struct i2c_client - represent an I2C slave device
  185.  * @flags: I2C_CLIENT_TEN indicates the device uses a ten bit chip address;
  186.  *    I2C_CLIENT_PEC indicates it uses SMBus Packet Error Checking
  187.  * @addr: Address used on the I2C bus connected to the parent adapter.
  188.  * @name: Indicates the type of the device, usually a chip name that's
  189.  *    generic enough to hide second-sourcing and compatible revisions.
  190.  * @adapter: manages the bus segment hosting this I2C device
  191.  * @driver: device's driver, hence pointer to access routines
  192.  * @dev: Driver model device node for the slave.
  193.  * @irq: indicates the IRQ generated by this device (if any)
  194.  * @list: list of active/busy clients (DEPRECATED)
  195.  * @detected: member of an i2c_driver.clients list
  196.  * @released: used to synchronize client releases & detaches and references
  197.  *
  198.  * An i2c_client identifies a single device (i.e. chip) connected to an
  199.  * i2c bus. The behaviour exposed to Linux is defined by the driver
  200.  * managing the device.
  201.  */
  202. struct i2c_client {
  203.     unsigned short flags;        /* div., see below        */
  204.     unsigned short addr;        /* chip address - NOTE: 7bit    */
  205.                     /* addresses are stored in the    */
  206.                     /* _LOWER_ 7 bits        */
  207.     char name[I2C_NAME_SIZE];
  208.     struct i2c_adapter *adapter;    /* the adapter we sit on    */
  209.     struct i2c_driver *driver;    /* and our access routines    */
  210.     struct device dev;        /* the device structure        */
  211.     int irq;            /* irq issued by device        */
  212.     struct list_head list;        /* DEPRECATED */
  213.     struct list_head detected;
  214.     struct completion released;
  215. };
  216. #define to_i2c_client(d) container_of(d, struct i2c_client, dev)
  217.  
  218. extern struct i2c_client *i2c_verify_client(struct device *dev);
  219.  
  220. static inline struct i2c_client *kobj_to_i2c_client(struct kobject *kobj)
  221. {
  222.     struct device * const dev = container_of(kobj, struct device, kobj);
  223.     return to_i2c_client(dev);
  224. }
  225.  
  226. static inline void *i2c_get_clientdata(const struct i2c_client *dev)
  227. {
  228.     return dev_get_drvdata(&dev->dev);
  229. }
  230.  
  231. static inline void i2c_set_clientdata(struct i2c_client *dev, void *data)
  232. {
  233.     dev_set_drvdata(&dev->dev, data);
  234. }
  235.  
  236. /**
  237.  * struct i2c_board_info - template for device creation
  238.  * @type: chip type, to initialize i2c_client.name
  239.  * @flags: to initialize i2c_client.flags
  240.  * @addr: stored in i2c_client.addr
  241.  * @platform_data: stored in i2c_client.dev.platform_data
  242.  * @archdata: copied into i2c_client.dev.archdata
  243.  * @irq: stored in i2c_client.irq
  244.  *
  245.  * I2C doesn't actually support hardware probing, although controllers and
  246.  * devices may be able to use I2C_SMBUS_QUICK to tell whether or not there's
  247.  * a device at a given address.  Drivers commonly need more information than
  248.  * that, such as chip type, configuration, associated IRQ, and so on.
  249.  *
  250.  * i2c_board_info is used to build tables of information listing I2C devices
  251.  * that are present.  This information is used to grow the driver model tree
  252.  * for "new style" I2C drivers.  For mainboards this is done statically using
  253.  * i2c_register_board_info(); bus numbers identify adapters that aren't
  254.  * yet available.  For add-on boards, i2c_new_device() does this dynamically
  255.  * with the adapter already known.
  256.  */
  257. struct i2c_board_info {
  258.     char        type[I2C_NAME_SIZE];
  259.     unsigned short    flags;
  260.     unsigned short    addr;
  261.     void        *platform_data;
  262.     struct dev_archdata    *archdata;
  263.     int        irq;
  264. };
  265.  
  266. /**
  267.  * I2C_BOARD_INFO - macro used to list an i2c device and its address
  268.  * @dev_type: identifies the device type
  269.  * @dev_addr: the device's address on the bus.
  270.  *
  271.  * This macro initializes essential fields of a struct i2c_board_info,
  272.  * declaring what has been provided on a particular board.  Optional
  273.  * fields (such as associated irq, or device-specific platform_data)
  274.  * are provided using conventional syntax.
  275.  */
  276. #define I2C_BOARD_INFO(dev_type, dev_addr) \
  277.     .type = (dev_type), .addr = (dev_addr)
  278.  
  279.  
  280. /* Add-on boards should register/unregister their devices; e.g. a board
  281.  * with integrated I2C, a config eeprom, sensors, and a codec that's
  282.  * used in conjunction with the primary hardware.
  283.  */
  284. extern struct i2c_client *
  285. i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info);
  286.  
  287. /* If you don't know the exact address of an I2C device, use this variant
  288.  * instead, which can probe for device presence in a list of possible
  289.  * addresses.
  290.  */
  291. extern struct i2c_client *
  292. i2c_new_probed_device(struct i2c_adapter *adap,
  293.               struct i2c_board_info *info,
  294.               unsigned short const *addr_list);
  295.  
  296. /* For devices that use several addresses, use i2c_new_dummy() to make
  297.  * client handles for the extra addresses.
  298.  */
  299. extern struct i2c_client *
  300. i2c_new_dummy(struct i2c_adapter *adap, u16 address);
  301.  
  302. extern void i2c_unregister_device(struct i2c_client *);
  303.  
  304. /* Mainboard arch_initcall() code should register all its I2C devices.
  305.  * This is done at arch_initcall time, before declaring any i2c adapters.
  306.  * Modules for add-on boards must use other calls.
  307.  */
  308. #ifdef CONFIG_I2C_BOARDINFO
  309. extern int
  310. i2c_register_board_info(int busnum, struct i2c_board_info const *info,
  311.             unsigned n);
  312. #else
  313. static inline int
  314. i2c_register_board_info(int busnum, struct i2c_board_info const *info,
  315.             unsigned n)
  316. {
  317.     return 0;
  318. }
  319. #endif
  320.  
  321. /*
  322.  * The following structs are for those who like to implement new bus drivers:
  323.  * i2c_algorithm is the interface to a class of hardware solutions which can
  324.  * be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584
  325.  * to name two of the most common.
  326.  */
  327. struct i2c_algorithm {
  328.     /* If an adapter algorithm can't do I2C-level access, set master_xfer
  329.        to NULL. If an adapter algorithm can do SMBus access, set
  330.        smbus_xfer. If set to NULL, the SMBus protocol is simulated
  331.        using common I2C messages */
  332.     /* master_xfer should return the number of messages successfully
  333.        processed, or a negative value on error */
  334.     int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
  335.                int num);
  336.     int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,
  337.                unsigned short flags, char read_write,
  338.                u8 command, int size, union i2c_smbus_data *data);
  339.  
  340.     /* To determine what the adapter supports */
  341.     u32 (*functionality) (struct i2c_adapter *);
  342. };
  343.  
  344. /*
  345.  * i2c_adapter is the structure used to identify a physical i2c bus along
  346.  * with the access algorithms necessary to access it.
  347.  */
  348. struct i2c_adapter {
  349.     struct module *owner;
  350.     unsigned int id;
  351.     unsigned int class;          /* classes to allow probing for */
  352.     const struct i2c_algorithm *algo; /* the algorithm to access the bus */
  353.     void *algo_data;
  354.  
  355.     /* --- administration stuff. */
  356.     int (*client_register)(struct i2c_client *);
  357.     int (*client_unregister)(struct i2c_client *);
  358.  
  359.     /* data fields that are valid for all devices    */
  360.     u8 level;             /* nesting level for lockdep */
  361.     struct mutex bus_lock;
  362.     struct mutex clist_lock;
  363.  
  364.     int timeout;
  365.     int retries;
  366.     struct device dev;        /* the adapter device */
  367.  
  368.     int nr;
  369.     struct list_head clients;    /* DEPRECATED */
  370.     char name[48];
  371.     struct completion dev_released;
  372. };
  373. #define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
  374.  
  375. static inline void *i2c_get_adapdata(const struct i2c_adapter *dev)
  376. {
  377.     return dev_get_drvdata(&dev->dev);
  378. }
  379.  
  380. static inline void i2c_set_adapdata(struct i2c_adapter *dev, void *data)
  381. {
  382.     dev_set_drvdata(&dev->dev, data);
  383. }
  384.  
  385. /*flags for the client struct: */
  386. #define I2C_CLIENT_PEC    0x04        /* Use Packet Error Checking */
  387. #define I2C_CLIENT_TEN    0x10        /* we have a ten bit chip address */
  388.                     /* Must equal I2C_M_TEN below */
  389. #define I2C_CLIENT_WAKE    0x80        /* for board_info; true iff can wake */
  390.  
  391. /* i2c adapter classes (bitmask) */
  392. #define I2C_CLASS_HWMON        (1<<0)    /* lm_sensors, ... */
  393. #define I2C_CLASS_TV_ANALOG    (1<<1)    /* bttv + friends */
  394. #define I2C_CLASS_TV_DIGITAL    (1<<2)    /* dvb cards */
  395. #define I2C_CLASS_DDC        (1<<3)    /* DDC bus on graphics adapters */
  396. #define I2C_CLASS_CAM_ANALOG    (1<<4)    /* camera with analog CCD */
  397. #define I2C_CLASS_CAM_DIGITAL    (1<<5)    /* most webcams */
  398. #define I2C_CLASS_SOUND        (1<<6)    /* sound devices */
  399. #define I2C_CLASS_SPD        (1<<7)    /* SPD EEPROMs and similar */
  400. #define I2C_CLASS_ALL        (UINT_MAX) /* all of the above */
  401.  
  402. /* i2c_client_address_data is the struct for holding default client
  403.  * addresses for a driver and for the parameters supplied on the
  404.  * command line
  405.  */
  406. struct i2c_client_address_data {
  407.     const unsigned short *normal_i2c;
  408.     const unsigned short *probe;
  409.     const unsigned short *ignore;
  410.     const unsigned short * const *forces;
  411. };
  412.  
  413. /* Internal numbers to terminate lists */
  414. #define I2C_CLIENT_END        0xfffeU
  415.  
  416. /* The numbers to use to set I2C bus address */
  417. #define ANY_I2C_BUS        0xffff
  418.  
  419.  
  420. /* ----- functions exported by i2c.o */
  421.  
  422. /* administration...
  423.  */
  424. extern int i2c_add_adapter(struct i2c_adapter *);
  425. extern int i2c_del_adapter(struct i2c_adapter *);
  426. extern int i2c_add_numbered_adapter(struct i2c_adapter *);
  427.  
  428. extern int i2c_register_driver(struct module *, struct i2c_driver *);
  429. extern void i2c_del_driver(struct i2c_driver *);
  430.  
  431. static inline int i2c_add_driver(struct i2c_driver *driver)
  432. {
  433.     return i2c_register_driver(THIS_MODULE, driver);
  434. }
  435.  
  436. extern int i2c_attach_client(struct i2c_client *);
  437. extern int i2c_detach_client(struct i2c_client *);
  438.  
  439. extern struct i2c_client *i2c_use_client(struct i2c_client *client);
  440. extern void i2c_release_client(struct i2c_client *client);
  441.  
  442. /* call the i2c_client->command() of all attached clients with
  443.  * the given arguments */
  444. extern void i2c_clients_command(struct i2c_adapter *adap,
  445.                 unsigned int cmd, void *arg);
  446.  
  447. /* Detect function. It iterates over all possible addresses itself.
  448.  * It will only call found_proc if some client is connected at the
  449.  * specific address (unless a 'force' matched);
  450.  */
  451. extern int i2c_probe(struct i2c_adapter *adapter,
  452.         const struct i2c_client_address_data *address_data,
  453.         int (*found_proc) (struct i2c_adapter *, int, int));
  454.  
  455. extern struct i2c_adapter *i2c_get_adapter(int id);
  456. extern void i2c_put_adapter(struct i2c_adapter *adap);
  457.  
  458.  
  459. /* Return the functionality mask */
  460. static inline u32 i2c_get_functionality(struct i2c_adapter *adap)
  461. {
  462.     return adap->algo->functionality(adap);
  463. }
  464.  
  465. /* Return 1 if adapter supports everything we need, 0 if not. */
  466. static inline int i2c_check_functionality(struct i2c_adapter *adap, u32 func)
  467. {
  468.     return (func & i2c_get_functionality(adap)) == func;
  469. }
  470.  
  471. /* Return the adapter number for a specific adapter */
  472. static inline int i2c_adapter_id(struct i2c_adapter *adap)
  473. {
  474.     return adap->nr;
  475. }
  476. #endif /* __KERNEL__ */
  477.  
  478. /**
  479.  * struct i2c_msg - an I2C transaction segment beginning with START
  480.  * @addr: Slave address, either seven or ten bits.  When this is a ten
  481.  *    bit address, I2C_M_TEN must be set in @flags and the adapter
  482.  *    must support I2C_FUNC_10BIT_ADDR.
  483.  * @flags: I2C_M_RD is handled by all adapters.  No other flags may be
  484.  *    provided unless the adapter exported the relevant I2C_FUNC_*
  485.  *    flags through i2c_check_functionality().
  486.  * @len: Number of data bytes in @buf being read from or written to the
  487.  *    I2C slave address.  For read transactions where I2C_M_RECV_LEN
  488.  *    is set, the caller guarantees that this buffer can hold up to
  489.  *    32 bytes in addition to the initial length byte sent by the
  490.  *    slave (plus, if used, the SMBus PEC); and this value will be
  491.  *    incremented by the number of block data bytes received.
  492.  * @buf: The buffer into which data is read, or from which it's written.
  493.  *
  494.  * An i2c_msg is the low level representation of one segment of an I2C
  495.  * transaction.  It is visible to drivers in the @i2c_transfer() procedure,
  496.  * to userspace from i2c-dev, and to I2C adapter drivers through the
  497.  * @i2c_adapter.@master_xfer() method.
  498.  *
  499.  * Except when I2C "protocol mangling" is used, all I2C adapters implement
  500.  * the standard rules for I2C transactions.  Each transaction begins with a
  501.  * START.  That is followed by the slave address, and a bit encoding read
  502.  * versus write.  Then follow all the data bytes, possibly including a byte
  503.  * with SMBus PEC.  The transfer terminates with a NAK, or when all those
  504.  * bytes have been transferred and ACKed.  If this is the last message in a
  505.  * group, it is followed by a STOP.  Otherwise it is followed by the next
  506.  * @i2c_msg transaction segment, beginning with a (repeated) START.
  507.  *
  508.  * Alternatively, when the adapter supports I2C_FUNC_PROTOCOL_MANGLING then
  509.  * passing certain @flags may have changed those standard protocol behaviors.
  510.  * Those flags are only for use with broken/nonconforming slaves, and with
  511.  * adapters which are known to support the specific mangling options they
  512.  * need (one or more of IGNORE_NAK, NO_RD_ACK, NOSTART, and REV_DIR_ADDR).
  513.  */
  514. struct i2c_msg {
  515.     __u16 addr;    /* slave address            */
  516.     __u16 flags;
  517. #define I2C_M_TEN        0x0010    /* this is a ten bit chip address */
  518. #define I2C_M_RD        0x0001    /* read data, from slave to master */
  519. #define I2C_M_NOSTART        0x4000    /* if I2C_FUNC_PROTOCOL_MANGLING */
  520. #define I2C_M_REV_DIR_ADDR    0x2000    /* if I2C_FUNC_PROTOCOL_MANGLING */
  521. #define I2C_M_IGNORE_NAK    0x1000    /* if I2C_FUNC_PROTOCOL_MANGLING */
  522. #define I2C_M_NO_RD_ACK        0x0800    /* if I2C_FUNC_PROTOCOL_MANGLING */
  523. #define I2C_M_RECV_LEN        0x0400    /* length will be first received byte */
  524.     __u16 len;        /* msg length                */
  525.     __u8 *buf;        /* pointer to msg data            */
  526. };
  527.  
  528. /* To determine what functionality is present */
  529.  
  530. #define I2C_FUNC_I2C            0x00000001
  531. #define I2C_FUNC_10BIT_ADDR        0x00000002
  532. #define I2C_FUNC_PROTOCOL_MANGLING    0x00000004 /* I2C_M_NOSTART etc. */
  533. #define I2C_FUNC_SMBUS_PEC        0x00000008
  534. #define I2C_FUNC_SMBUS_BLOCK_PROC_CALL    0x00008000 /* SMBus 2.0 */
  535. #define I2C_FUNC_SMBUS_QUICK        0x00010000
  536. #define I2C_FUNC_SMBUS_READ_BYTE    0x00020000
  537. #define I2C_FUNC_SMBUS_WRITE_BYTE    0x00040000
  538. #define I2C_FUNC_SMBUS_READ_BYTE_DATA    0x00080000
  539. #define I2C_FUNC_SMBUS_WRITE_BYTE_DATA    0x00100000
  540. #define I2C_FUNC_SMBUS_READ_WORD_DATA    0x00200000
  541. #define I2C_FUNC_SMBUS_WRITE_WORD_DATA    0x00400000
  542. #define I2C_FUNC_SMBUS_PROC_CALL    0x00800000
  543. #define I2C_FUNC_SMBUS_READ_BLOCK_DATA    0x01000000
  544. #define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000
  545. #define I2C_FUNC_SMBUS_READ_I2C_BLOCK    0x04000000 /* I2C-like block xfer  */
  546. #define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK    0x08000000 /* w/ 1-byte reg. addr. */
  547.  
  548. #define I2C_FUNC_SMBUS_BYTE        (I2C_FUNC_SMBUS_READ_BYTE | \
  549.                      I2C_FUNC_SMBUS_WRITE_BYTE)
  550. #define I2C_FUNC_SMBUS_BYTE_DATA    (I2C_FUNC_SMBUS_READ_BYTE_DATA | \
  551.                      I2C_FUNC_SMBUS_WRITE_BYTE_DATA)
  552. #define I2C_FUNC_SMBUS_WORD_DATA    (I2C_FUNC_SMBUS_READ_WORD_DATA | \
  553.                      I2C_FUNC_SMBUS_WRITE_WORD_DATA)
  554. #define I2C_FUNC_SMBUS_BLOCK_DATA    (I2C_FUNC_SMBUS_READ_BLOCK_DATA | \
  555.                      I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)
  556. #define I2C_FUNC_SMBUS_I2C_BLOCK    (I2C_FUNC_SMBUS_READ_I2C_BLOCK | \
  557.                      I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)
  558.  
  559. #define I2C_FUNC_SMBUS_EMUL        (I2C_FUNC_SMBUS_QUICK | \
  560.                      I2C_FUNC_SMBUS_BYTE | \
  561.                      I2C_FUNC_SMBUS_BYTE_DATA | \
  562.                      I2C_FUNC_SMBUS_WORD_DATA | \
  563.                      I2C_FUNC_SMBUS_PROC_CALL | \
  564.                      I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | \
  565.                      I2C_FUNC_SMBUS_I2C_BLOCK | \
  566.                      I2C_FUNC_SMBUS_PEC)
  567.  
  568. /*
  569.  * Data for SMBus Messages
  570.  */
  571. #define I2C_SMBUS_BLOCK_MAX    32    /* As specified in SMBus standard */
  572. union i2c_smbus_data {
  573.     __u8 byte;
  574.     __u16 word;
  575.     __u8 block[I2C_SMBUS_BLOCK_MAX + 2]; /* block[0] is used for length */
  576.                    /* and one more for user-space compatibility */
  577. };
  578.  
  579. /* i2c_smbus_xfer read or write markers */
  580. #define I2C_SMBUS_READ    1
  581. #define I2C_SMBUS_WRITE    0
  582.  
  583. /* SMBus transaction types (size parameter in the above functions)
  584.    Note: these no longer correspond to the (arbitrary) PIIX4 internal codes! */
  585. #define I2C_SMBUS_QUICK            0
  586. #define I2C_SMBUS_BYTE            1
  587. #define I2C_SMBUS_BYTE_DATA        2
  588. #define I2C_SMBUS_WORD_DATA        3
  589. #define I2C_SMBUS_PROC_CALL        4
  590. #define I2C_SMBUS_BLOCK_DATA        5
  591. #define I2C_SMBUS_I2C_BLOCK_BROKEN  6
  592. #define I2C_SMBUS_BLOCK_PROC_CALL   7        /* SMBus 2.0 */
  593. #define I2C_SMBUS_I2C_BLOCK_DATA    8
  594.  
  595.  
  596. #ifdef __KERNEL__
  597.  
  598. /* These defines are used for probing i2c client addresses */
  599. /* The length of the option lists */
  600. #define I2C_CLIENT_MAX_OPTS 48
  601.  
  602. /* Default fill of many variables */
  603. #define I2C_CLIENT_DEFAULTS {I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  604.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  605.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  606.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  607.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  608.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  609.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  610.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  611.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  612.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  613.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  614.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  615.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  616.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  617.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  618.                  I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END}
  619.  
  620. /* I2C_CLIENT_MODULE_PARM creates a module parameter, and puts it in the
  621.    module header */
  622.  
  623. #define I2C_CLIENT_MODULE_PARM(var,desc) \
  624.   static unsigned short var[I2C_CLIENT_MAX_OPTS] = I2C_CLIENT_DEFAULTS; \
  625.   static unsigned int var##_num; \
  626.   module_param_array(var, short, &var##_num, 0); \
  627.   MODULE_PARM_DESC(var, desc)
  628.  
  629. #define I2C_CLIENT_MODULE_PARM_FORCE(name)                \
  630. I2C_CLIENT_MODULE_PARM(force_##name,                    \
  631.                "List of adapter,address pairs which are "    \
  632.                "unquestionably assumed to contain a `"        \
  633.                # name "' chip")
  634.  
  635.  
  636. #define I2C_CLIENT_INSMOD_COMMON                    \
  637. I2C_CLIENT_MODULE_PARM(probe, "List of adapter,address pairs to scan "    \
  638.                "additionally");                    \
  639. I2C_CLIENT_MODULE_PARM(ignore, "List of adapter,address pairs not to "    \
  640.                "scan");                        \
  641. static const struct i2c_client_address_data addr_data = {        \
  642.     .normal_i2c    = normal_i2c,                    \
  643.     .probe        = probe,                    \
  644.     .ignore        = ignore,                    \
  645.     .forces        = forces,                    \
  646. }
  647.  
  648. #define I2C_CLIENT_FORCE_TEXT \
  649.     "List of adapter,address pairs to boldly assume to be present"
  650.  
  651. /* These are the ones you want to use in your own drivers. Pick the one
  652.    which matches the number of devices the driver differenciates between. */
  653. #define I2C_CLIENT_INSMOD                        \
  654. I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);            \
  655. static const unsigned short * const forces[] = { force, NULL };        \
  656. I2C_CLIENT_INSMOD_COMMON
  657.  
  658. #define I2C_CLIENT_INSMOD_1(chip1)                    \
  659. enum chips { any_chip, chip1 };                        \
  660. I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);            \
  661. I2C_CLIENT_MODULE_PARM_FORCE(chip1);                    \
  662. static const unsigned short * const forces[] =    { force,        \
  663.     force_##chip1, NULL };                        \
  664. I2C_CLIENT_INSMOD_COMMON
  665.  
  666. #define I2C_CLIENT_INSMOD_2(chip1, chip2)                \
  667. enum chips { any_chip, chip1, chip2 };                    \
  668. I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);            \
  669. I2C_CLIENT_MODULE_PARM_FORCE(chip1);                    \
  670. I2C_CLIENT_MODULE_PARM_FORCE(chip2);                    \
  671. static const unsigned short * const forces[] =    { force,        \
  672.     force_##chip1, force_##chip2, NULL };                \
  673. I2C_CLIENT_INSMOD_COMMON
  674.  
  675. #define I2C_CLIENT_INSMOD_3(chip1, chip2, chip3)            \
  676. enum chips { any_chip, chip1, chip2, chip3 };                \
  677. I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);            \
  678. I2C_CLIENT_MODULE_PARM_FORCE(chip1);                    \
  679. I2C_CLIENT_MODULE_PARM_FORCE(chip2);                    \
  680. I2C_CLIENT_MODULE_PARM_FORCE(chip3);                    \
  681. static const unsigned short * const forces[] =    { force,        \
  682.     force_##chip1, force_##chip2, force_##chip3, NULL };        \
  683. I2C_CLIENT_INSMOD_COMMON
  684.  
  685. #define I2C_CLIENT_INSMOD_4(chip1, chip2, chip3, chip4)            \
  686. enum chips { any_chip, chip1, chip2, chip3, chip4 };            \
  687. I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);            \
  688. I2C_CLIENT_MODULE_PARM_FORCE(chip1);                    \
  689. I2C_CLIENT_MODULE_PARM_FORCE(chip2);                    \
  690. I2C_CLIENT_MODULE_PARM_FORCE(chip3);                    \
  691. I2C_CLIENT_MODULE_PARM_FORCE(chip4);                    \
  692. static const unsigned short * const forces[] =    { force,        \
  693.     force_##chip1, force_##chip2, force_##chip3,            \
  694.     force_##chip4, NULL};                        \
  695. I2C_CLIENT_INSMOD_COMMON
  696.  
  697. #define I2C_CLIENT_INSMOD_5(chip1, chip2, chip3, chip4, chip5)        \
  698. enum chips { any_chip, chip1, chip2, chip3, chip4, chip5 };        \
  699. I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);            \
  700. I2C_CLIENT_MODULE_PARM_FORCE(chip1);                    \
  701. I2C_CLIENT_MODULE_PARM_FORCE(chip2);                    \
  702. I2C_CLIENT_MODULE_PARM_FORCE(chip3);                    \
  703. I2C_CLIENT_MODULE_PARM_FORCE(chip4);                    \
  704. I2C_CLIENT_MODULE_PARM_FORCE(chip5);                    \
  705. static const unsigned short * const forces[] = { force,            \
  706.     force_##chip1, force_##chip2, force_##chip3,            \
  707.     force_##chip4, force_##chip5, NULL };                \
  708. I2C_CLIENT_INSMOD_COMMON
  709.  
  710. #define I2C_CLIENT_INSMOD_6(chip1, chip2, chip3, chip4, chip5, chip6)    \
  711. enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6 };    \
  712. I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);            \
  713. I2C_CLIENT_MODULE_PARM_FORCE(chip1);                    \
  714. I2C_CLIENT_MODULE_PARM_FORCE(chip2);                    \
  715. I2C_CLIENT_MODULE_PARM_FORCE(chip3);                    \
  716. I2C_CLIENT_MODULE_PARM_FORCE(chip4);                    \
  717. I2C_CLIENT_MODULE_PARM_FORCE(chip5);                    \
  718. I2C_CLIENT_MODULE_PARM_FORCE(chip6);                    \
  719. static const unsigned short * const forces[] = { force,            \
  720.     force_##chip1, force_##chip2, force_##chip3,            \
  721.     force_##chip4, force_##chip5, force_##chip6, NULL };        \
  722. I2C_CLIENT_INSMOD_COMMON
  723.  
  724. #define I2C_CLIENT_INSMOD_7(chip1, chip2, chip3, chip4, chip5, chip6, chip7) \
  725. enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6,    \
  726.          chip7 };                            \
  727. I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);            \
  728. I2C_CLIENT_MODULE_PARM_FORCE(chip1);                    \
  729. I2C_CLIENT_MODULE_PARM_FORCE(chip2);                    \
  730. I2C_CLIENT_MODULE_PARM_FORCE(chip3);                    \
  731. I2C_CLIENT_MODULE_PARM_FORCE(chip4);                    \
  732. I2C_CLIENT_MODULE_PARM_FORCE(chip5);                    \
  733. I2C_CLIENT_MODULE_PARM_FORCE(chip6);                    \
  734. I2C_CLIENT_MODULE_PARM_FORCE(chip7);                    \
  735. static const unsigned short * const forces[] = { force,            \
  736.     force_##chip1, force_##chip2, force_##chip3,            \
  737.     force_##chip4, force_##chip5, force_##chip6,            \
  738.     force_##chip7, NULL };                        \
  739. I2C_CLIENT_INSMOD_COMMON
  740.  
  741. #define I2C_CLIENT_INSMOD_8(chip1, chip2, chip3, chip4, chip5, chip6, chip7, chip8) \
  742. enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6,    \
  743.          chip7, chip8 };                        \
  744. I2C_CLIENT_MODULE_PARM(force, I2C_CLIENT_FORCE_TEXT);            \
  745. I2C_CLIENT_MODULE_PARM_FORCE(chip1);                    \
  746. I2C_CLIENT_MODULE_PARM_FORCE(chip2);                    \
  747. I2C_CLIENT_MODULE_PARM_FORCE(chip3);                    \
  748. I2C_CLIENT_MODULE_PARM_FORCE(chip4);                    \
  749. I2C_CLIENT_MODULE_PARM_FORCE(chip5);                    \
  750. I2C_CLIENT_MODULE_PARM_FORCE(chip6);                    \
  751. I2C_CLIENT_MODULE_PARM_FORCE(chip7);                    \
  752. I2C_CLIENT_MODULE_PARM_FORCE(chip8);                    \
  753. static const unsigned short * const forces[] = { force,            \
  754.     force_##chip1, force_##chip2, force_##chip3,            \
  755.     force_##chip4, force_##chip5, force_##chip6,            \
  756.     force_##chip7, force_##chip8, NULL };                \
  757. I2C_CLIENT_INSMOD_COMMON
  758. #endif /* __KERNEL__ */
  759. #endif /* _LINUX_I2C_H */
  760.